﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

//二级指针

//下面创造了变量a，并且用指针变量p来存放a的地址。
//int a = 10;
//int* p = &a;

//那么指针变量也是变量，也存在地址，我们就管存放指针
//变量地址的称作为二级指针
//如下：
//int main()
//{
//	int a = 10;
//	int* p = &a;
//	int** pp = &p;
//	return 0;
//}

//解应用操作
//* pp = p = &a;
//**pp = *p = a;


//指针数组
//类比：
//整形数组：存放整型的数组;
//字符数组：存放字符的数组;
//指针数组：存放指针的数组;

//int arr1[3] = { (int),(int),(int) };
//char arr2[3] = { (char),(char),(char) };
//int* arr3[3] = { (int*),(int*),(int*) };


//指针数组模拟二维数组
//如下：
//int main()
//{
//	int arr1[5] = {1,2,3,4,5};
//	int arr2[5] = {2,3,4,5,6};
//	int arr3[5] = {3,4,5,6,7};
//	//数组名是数组⾸元素的地址，
//	// 类型是int*的，就可以存放在parr数组中
//
//	int* parr[3] = { arr1,arr2,arr3 };
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < 3; i++)
//	{
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d ", parr[i][j]);
//		}
//		printf("\n");
//	}
//	return 0;
//}


//字符指针变量

//字符指针类型 - char*
//一般我们使用时如下：
//int main()
//{
//	char ch = 'w';
//	char* p = &ch;//p = &ch;  *p = ch;
//	*p = 'w';
//	printf("%c", *p);
//	return 0;
//}

//另外的使用方式
//在这里是把字符串"hello world"的首字符的地址放入了
//char* pa中，不是将字符串放入，既然是首地址的放入
//char* pa 所指向的地址是不可修改的，建议在前加上
// const
//int main()
//{
//	const char* pa = "hello world";
//	printf("%s\n", pa);
//	return 0;
//}


//数组指针变量
//类比：

//整型指针变量：int* p;
//存放的是整型变量的地址，可以指向整型数据的指针

//浮点型指针变量：float* p;
//存放的是浮点型变量的地址，可以指向浮点型数据的指针

//数组指针变量
//存放的是数组的地址，可以指向数组的指针变量

//int(*p)[10];
//*与p结合说明p是一个指针变量，然后所指的是一个大小为
//[10]的数组，而前面的int则是数组的类型。


//数组指针变量的初始化 - 赋值
//int arr[10] = { 0 };
//&arr;//所得到的是数组的地址
//int(*p) = &arr;



//二维数组传参的本质

//正常打印二维数组
//void text(int arr[3][5], int r, int c)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < r; i++)
//	{
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//		printf("\n");
//	}
//}
//int main()
//{
//	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{6,7,8,9,10} };
//	text(arr, 3, 5);
//	return 0;
//}

//本质
//那就意味着⼆维数组传参本质上也是传递了地址，传递的是第⼀
//⾏这个⼀维数组的地址
//void text(int (*p)[5], int r, int c)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < r; i++)
//	{
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", *(*(p+i)+j));//一种： (*(p+i))[j]
//		}
//		printf("\n");
//	}
//}
//int main()
//{
//	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{6,7,8,9,10} };
//	text(arr, 3, 5);
//	return 0;
//}


//函数指针变量的使用
//通过函数指针调用指针指向的函数
//int add(int x, int y)
//{
//	return x + y;
//}
//int main()
//{
//	int (*p)(int, int) = add;
//	printf("%d\n", p(3, 5));
//	printf("%d\n", (*p)(3, 5));
//	return 0;
//}


//typedef关键字
//可以用来类型重命名，可以将复杂简单化
//如：
//int main()
//{
//	typedef unsigned int unit;
//	unit a = 10;
//	printf("%zd\n", a);
//	return 0;
//}



////字符串旋转结果
////写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。
//#include <string.h>
//#include <stdio.h>
//
//void Left_turn(char* s1, int len, int n)
//{
//	n = n % len;//查看次数 len = 4;
//	int i = 0;
//	for (i = 0; i < n; i++)//n == 2;
//	{
//		int j = 0;
//		char a = s1[0];
//		for (j = 0; j < len - 1; j++)
//		{
//			s1[j] = s1[j + 1];
//		}
//		s1[j] = a;
//	}
//}
//
////检查是否一致
//void chat_sz(char* s1, char* s2)
//{
//	int i = strcmp(s1, s2);
//	if (i == 0)
//	{
//		printf("旋转正确，字符串相同\n");
//	}
//	if (i == -1)
//	{
//		printf("旋转错误，字符串不同\n");
//	}
//}
//int main()
//{
//	//创建
//	char s1[] = "ABCD";
//	char s2[] = "CDAB";
//	printf("旋转前：    %s\n", s1);
//	printf("对照字符串：%s\n", s2);
//	//输入左旋次数
//	printf("请输入左旋的次数：");
//	int n = 0;
//	scanf("%d", &n);
//	//进行左旋
//	int len = strlen(s1);
//	Left_turn(s1, len, n);
//	printf("旋转后：    %s\n", s1);
//	printf("对照字符串：%s\n", s2);
//	//检验
//	chat_sz(s1, s2);
//	return 0;
//}


//int main()
//{
//	int arr[7][7] = { 0 };
//	int i = 0;
//	for (i = 0; i < 7; i++)
//	{
//		int j = 0;
//		for (j = 0; j < 7; j++)
//		{
//			arr[i][j] = i;
//		}
//	}printf("\n");
//	int k = 0;
//	for (k = 0; k < 7; k++)
//	{
//		int w = 0;
//		for (w = 0; w < 7; w++)
//		{
//			printf("%d", arr[k][w]);
//		}
//		printf("\n");
//	}
//	return 0;
//}


//冒泡排序
//解释：将一组凌乱的数据进行有序的排列，如升序或者降序
//列如：
//杂乱：2，6，4，9，8，5，1，7，3
//升序：1，2，3，4，5，6，7，8，9
//降序：9，8，7，6，5，4，3，2，1

//具体可以应用于价格排序等等。

//代码实现

void Bubble_sort(int arr[], int sz)
{
	int i = 0;
	for(i = 0; i < sz - 1; i++)//检查排序的数字次数如n个数字就需要n-1次
	{
		int flag = 1;//假设第一趟已经是有序的
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)//每次交换都会有一个排序正确所以为sz-1-i次
		{
			//升序
			if (arr[j] > arr[j + 1])
			{
				flag = 0;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (flag == 1) 
		{
			break;
		}
	}
}



int main()
{
	int arr[9] = { 2,6,4,9,8,5,1,7,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	printf("排序前：");
	for (i = 0; i < 9; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	//排序函数
	Bubble_sort(arr, sz);
	printf("排序后：");
	int j = 0;
	for (j = 0; j < 9; j++)
	{
		printf("%d ", arr[j]);
	}
	return 0;
}